import { defineStore } from 'pinia'
import { login, logout, getInfo } from '@/api/auth'
import { getToken, setToken, removeToken } from '@/utils/auth'
import { getUsers, updateUser, deleteUser, createUser } from '@/api/user'
import { ElMessage } from 'element-plus'

export const useUserStore = defineStore('user', {
  state: () => ({
    token: localStorage.getItem('token') || '',
    username: '',
    role: '',
    userId: null,
    permissions: [],
    name: '',
    avatar: '',
    roles: [],
    users: [],
    total: 0
  }),

  getters: {
    isLoggedIn: (state) => !!state.token,
    isSuperAdmin: (state) => state.role === 'SUPER_ADMIN',
    isAdmin: (state) => state.role === 'ADMIN',
    isUser: (state) => state.role === 'USER',
    
    // 权限检查函数
    hasPermission: (state) => (permission) => {
      if (state.role === 'SUPER_ADMIN') return true;
      return state.permissions.includes(permission);
    },
    
    // 查看详细统计数据权限
    canViewDetailedStats: (state) => {
      return state.role === 'SUPER_ADMIN' || state.role === 'ADMIN';
    },
    
    // 分类管理权限
    canManageCategories: (state) => {
      return state.role === 'SUPER_ADMIN' || state.role === 'ADMIN';
    },
    canEditCategories: (state) => {
      return state.role === 'SUPER_ADMIN' || state.role === 'ADMIN';
    },
    canDeleteCategories: (state) => {
      return state.role === 'SUPER_ADMIN' || state.role === 'ADMIN';
    },
    
    // 商品管理权限
    canManageProducts: (state) => {
      return state.role === 'SUPER_ADMIN' || state.role === 'ADMIN';
    },
    canBuyProducts: (state) => {
      return state.role === 'SUPER_ADMIN' || state.role === 'USER';
    },
    
    // 订单管理权限
    canManageAllOrders: (state) => {
      return state.role === 'SUPER_ADMIN';
    },
    canShipOrders: (state) => {
      return state.role === 'SUPER_ADMIN' || state.role === 'ADMIN';
    },
    canCompleteOrders: (state) => {
      return state.role === 'SUPER_ADMIN' || state.role === 'ADMIN';
    },
    
    // 用户管理权限
    canManageUsers: (state) => {
      return state.role === 'SUPER_ADMIN';
    },
    canViewUsers: (state) => {
      return state.role === 'SUPER_ADMIN' || state.role === 'ADMIN';
    }
  },

  actions: {
    // 登录
    async login(userInfo) {
      try {
        console.log('开始登录，用户信息:', userInfo)
        const { username, password } = userInfo
        
        if (!username || !password) {
          throw new Error('用户名和密码不能为空')
        }
        
        const res = await login({ 
          username: username.trim(), 
          password: password.trim() 
        })
        
        console.log('登录响应:', res)
        
        // 检查响应状态
        if (res.code === 200 || res.code === 0) {
          const { token, role, userId, id } = res.data
          if (!token) {
            throw new Error('登录失败：未获取到token')
          }
          
          this.token = token
          this.username = username
          this.role = role || 'SUPER_ADMIN'
          this.userId = userId || id || null // 使用 userId 或 id 字段
          
          // 保存 token 到 localStorage
          localStorage.setItem('token', token)
          ElMessage.success('登录成功')
          return res
        } else if (res.token) {
          // 处理直接返回token的情况
          this.token = res.token
          this.username = username
          this.role = res.role || 'SUPER_ADMIN'
          this.userId = res.userId || res.id || null // 使用 userId 或 id 字段
          
          // 保存 token 到 localStorage
          localStorage.setItem('token', res.token)
          ElMessage.success('登录成功')
          return {
            code: 200,
            data: {
              token: res.token,
              role: res.role || 'SUPER_ADMIN',
              userId: this.userId
            },
            message: 'success'
          }
        } else {
          const message = res.message || '登录失败'
          ElMessage.error(message)
          throw new Error(message)
        }
      } catch (error) {
        console.error('登录失败:', error)
        ElMessage.error(error.message || '登录失败')
        throw error
      }
    },

    // 获取用户信息
    async getInfo() {
      // 添加更多调试信息
      console.log('开始获取用户信息，当前状态:', {
        token: this.token ? '已存在' : '不存在',
        username: this.username,
        role: this.role,
        userId: this.userId
      });
      
      // 如果已经有基本的用户信息，直接返回，不再调用 API
      if (this.token && this.username && this.role && this.userId) {
        console.log('使用已有的完整用户信息，不再调用 API');
        return {
          username: this.username,
          role: this.role,
          userId: this.userId
        };
      }
      
      try {
        const res = await getInfo();
        console.log('API返回的用户信息:', res);
        
        if (res.code === 200 || res.code === 0) {
          const { username, role, id, userId } = res.data;
          this.username = username;
          this.role = role;
          
          // 保存用户ID，使用多种可能的字段名
          this.userId = userId || id || res.data.user_id || res.data.uid || null;
          
          console.log('用户信息更新成功:', {
            username: this.username,
            role: this.role,
            userId: this.userId
          });
          
          return res.data;
        } else {
          throw new Error(res.message || '获取用户信息失败');
        }
      } catch (error) {
        console.error('获取用户信息失败:', error);
        
        // 如果调用 API 失败，但有本地信息，则使用本地信息
        if (this.token) {
          // 如果是开发环境，为便于测试，设置一些默认值
          if (process.env.NODE_ENV === 'development') {
            if (!this.username) this.username = 'testuser';
            if (!this.role) this.role = 'USER';
            if (!this.userId) this.userId = '1001';
            
            console.log('开发环境：设置默认用户信息', {
              username: this.username,
              role: this.role,
              userId: this.userId
            });
            
            return {
              username: this.username,
              role: this.role,
              userId: this.userId
            };
          }
          
          // 如果没有角色信息，默认设置为普通用户
          if (!this.role) {
            this.role = 'USER';
          }
          
          return {
            username: this.username || '用户',
            role: this.role,
            userId: this.userId
          };
        }
        
        // 如果没有任何信息，则登录已失效
        this.resetState();
        throw new Error('登录已失效，请重新登录');
      }
    },

    // 登出
    async logout() {
      try {
        // 直接清除本地状态，不再调用后端 API
        this.resetState()
        ElMessage.success('退出登录成功')
        return true
      } catch (error) {
        console.error('登出失败:', error)
        // 确保即使出错也清除本地状态
        this.resetState()
        return true
      }
    },

    // 重置状态
    resetState() {
      this.token = ''
      this.username = ''
      this.role = ''
      this.userId = null
      localStorage.removeItem('token')
    },

    // 重置token
    resetToken() {
      this.token = ''
      localStorage.removeItem('token')
    },

    // 获取用户列表
    async getUsers(params) {
      try {
        const res = await getUsers(params)
        console.log('获取用户列表原始响应:', res)
        
        if (res.code === 200) {
          // 处理直接返回数组的情况
          if (Array.isArray(res.data)) {
            console.log('处理数组数据:', res.data)
            this.users = res.data
            // 如果直接返回数组，且请求中包含分页参数，则可能是后端没有正确处理分页
            // 此时需要手动计算总页数
            if (params && params.page && params.pageSize) {
              // 如果响应头中包含总数信息，优先使用
              const totalCount = res.headers?.['x-total-count'] || res.headers?.['X-Total-Count']
              if (totalCount) {
                this.total = parseInt(totalCount) || res.data.length
              } else {
                // 否则假设这是所有数据，设置总数
                this.total = Math.max(res.data.length, params.page * params.pageSize)
              }
              console.log('从数组响应计算总数:', this.total)
            } else {
              this.total = res.data.length
            }
          }
          // 处理分页数据的情况
          else if (res.data && res.data.records) {
            console.log('处理分页数据:', res.data)
            this.users = res.data.records
            this.total = res.data.total || res.data.records.length
            console.log('从分页响应获取总数:', this.total)
          }
          // 处理直接返回对象的情况
          else if (res.data) {
            console.log('处理对象数据:', res.data)
            this.users = [res.data]
            this.total = 1
          }
          // 处理空数据的情况
          else {
            console.log('处理空数据')
            this.users = []
            this.total = 0
          }
          return res
        }
        throw new Error(res.message || '获取用户列表失败')
      } catch (error) {
        console.error('获取用户列表失败:', error)
        this.users = []
        this.total = 0
        throw error
      }
    },

    // 创建用户
    async createUser(userData) {
      try {
        console.log('创建用户，原始数据:', userData)
        // 只发送必要的字段
        const userDataToSend = {
          username: userData.username,
          password: userData.password,
          role: userData.role
        }
        console.log('创建用户，处理后的数据:', userDataToSend)
        const res = await createUser(userDataToSend)
        console.log('创建用户响应:', res)
        
        // 处理不同的响应情况
        if (res === true || res.code === 200 || (res && Object.keys(res).length === 0)) {
          ElMessage.success('创建用户成功')
          // 刷新用户列表
          await this.getUsers()
          return true
        }
        
        // 如果响应不符合预期
        if (!res) {
          throw new Error('创建失败：服务器返回空响应')
        }
        throw new Error(res.message || '创建用户失败')
      } catch (error) {
        console.error('创建用户失败:', error)
        ElMessage.error(error.message || '创建用户失败')
        throw error
      }
    },

    // 更新用户
    async updateUser(userData) {
      try {
        console.log('更新用户，原始数据:', userData)
        // 只发送必要的字段
        const userDataToSend = {
          id: userData.id,
          username: userData.username,
          password: userData.password,
          role: userData.role
        }
        console.log('更新用户，处理后的数据:', userDataToSend)
        const res = await updateUser(userDataToSend.id, userDataToSend)
        if (res.code === 200) {
          ElMessage.success('更新用户成功')
          // 刷新用户列表
          await this.getUsers()
          return res
        }
        throw new Error(res.message || '更新用户失败')
      } catch (error) {
        console.error('更新用户失败:', error)
        ElMessage.error(error.message || '更新用户失败')
        throw error
      }
    },

    // 删除用户
    async deleteUser(userId) {
      try {
        console.log('开始删除用户，ID:', userId)
        if (!userId) {
          throw new Error('用户ID不能为空')
        }
        
        const res = await deleteUser(userId)
        if (res.code === 200) {
          ElMessage.success('删除用户成功')
          // 刷新用户列表
          await this.getUsers()
          return res
        }
        throw new Error(res.message || '删除用户失败')
      } catch (error) {
        console.error('删除用户失败:', error)
        ElMessage.error(error.message || '删除用户失败')
        throw error
      }
    }
  }
}) 